home *** CD-ROM | disk | FTP | other *** search
/ Delphi Developer's Kit 1996 / Delphi Developer's Kit 1996.iso / power / accum / accum.pas < prev    next >
Pascal/Delphi Source File  |  1995-12-22  |  14KB  |  343 lines
  1. unit Accum;
  2. {*******************************}
  3. { Author: Eric Uber             }
  4. { CIS Account: 71102,3034       }
  5. { Written: June 14th 1995.      }
  6. { Freeware, distribute at will. }
  7. {*******************************}
  8. interface
  9.  
  10. uses
  11.   SysUtils, WinTypes, WinProcs, Messages, Classes, Graphics, Controls,
  12.   Forms, Dialogs;
  13.  
  14. const
  15.   LONGINT_MIN = -2147483647;
  16.   LONGINT_MAX =  2147483647;
  17.  
  18. type
  19.   EMaxExceedError = class(Exception);
  20.   TAccumulator = class(TComponent)
  21.   private
  22.     { Private declarations }
  23.      FliValue      : LongInt;
  24.      FliStartValue : Longint;
  25.      FliMaxValue   : Longint;
  26.      FbExceptOnMaxValExceed: Boolean;
  27.  
  28.      fOnDivide     : TNotifyEvent;
  29.      fOnMultiply   : TNotifyEvent;
  30.      fOnAdd        : TNotifyEvent;
  31.      fOnSubtract   : TNotifyEvent;
  32.      fOnInc        : TNotifyEvent;
  33.      fOnDec        : TNotifyEvent;
  34.  
  35.      fOnSuccessDivide   : TNotifyEvent;
  36.      fOnSuccessMultiply : TNotifyEvent;
  37.      fOnSuccessAdd      : TNotifyEvent;
  38.      fOnSuccessSubtract : TNotifyEvent;
  39.      fOnSuccessInc      : TNotifyEvent;
  40.      fOnSuccessDec      : TNotifyEvent;
  41.  
  42.   protected
  43.     { Protected declarations }
  44.     procedure SetFliMaxValue(liInValue:LongInt);
  45.     procedure SetFliStartValue(liInValue:LongInt);
  46.   public
  47.     { Public declarations }
  48.      function  AccInc: Longint;
  49.      function  AccDec: Longint;
  50.      function  Add(liInValue: LongInt): LongInt;
  51.      function  Subtract(liInValue: LongInt): LongInt;
  52.      function  Multiply(liInValue: LongInt): LongInt;
  53.      function  Divide(liInValue: LongInt): LongInt;
  54.      function  GetCurrentValue: LongInt;
  55.      procedure Reset;
  56.   published
  57.     { Published declarations }
  58.      property MaxValue   : Longint read FliMaxValue write SetFliMaxValue;
  59.      property StartValue : Longint read FliStartValue write SetFliStartValue;
  60.      property ExceptOnMaxValExceed: Boolean read FbExceptOnMaxValExceed
  61.                                     Write FbExceptOnMaxValExceed;
  62.      property OnBeginAdd: TNotifyEvent read fOnAdd write fOnAdd;
  63.      property OnBeginSubtract: TNotifyEvent read fOnSubtract write fOnSubtract;
  64.      property OnBeginMultiply: TNotifyEvent read fOnMultiply write fOnMultiply;
  65.      property OnBeginDivide: TNotifyEvent read fOnDivide write fOnDivide;
  66.      property OnBeginInc: TNotifyEvent read fOnInc write fOnInc;
  67.      property OnBeginDec: TNotifyEvent read fOnDec write fOnDec;
  68.  
  69.      property OnSuccessAdd: TNotifyEvent read fOnSuccessAdd write fOnSuccessAdd;
  70.      property OnSuccessSubtract: TNotifyEvent read fOnSuccessSubtract write fOnSuccessSubtract;
  71.      property OnSuccessMultiply: TNotifyEvent read fOnSuccessMultiply write fOnSuccessMultiply;
  72.      property OnSuccessDivide: TNotifyEvent read fOnSuccessDivide write fOnSuccessDivide;
  73.      property OnSuccessInc: TNotifyEvent read fOnSuccessInc write fOnSuccessInc;
  74.      property OnSuccessDec: TNotifyEvent read fOnSuccessDec write fOnSuccessDec;
  75.   end;
  76.  
  77. procedure Register;
  78.  
  79. implementation
  80.  
  81. procedure Register;
  82. begin
  83.   RegisterComponents('Custom', [TAccumulator]);
  84. end;
  85.  
  86.  
  87. {----------------------------------------------------------}
  88. { Public Method: function TAccumulator.AccInc: LongInt;    }
  89. {----------------------------------------------------------}
  90. { Purpose: Increments the accumulators current value.      }
  91. {----------------------------------------------------------}
  92. { Returns: Result of computation or 0 (if                  }
  93. {          ExceptOnMaxValExceed is set to False and result }
  94. {          exceeds MaxValue). If ExceptOnMaxValExceed      }
  95. {          is set to true and the result exceeds MaxValue, }
  96. {          an exception called EMaxExceedError will occur. }
  97. {----------------------------------------------------------}
  98. function  TAccumulator.AccInc: LongInt;
  99. begin
  100.   if Assigned(fOnInc) then
  101.      fOnInc(self);
  102.  
  103.   if ( FliValue + 1 <= MaxValue ) or (MaxValue = 0) then
  104.      begin
  105.        Inc(FliValue);
  106.        if Assigned(fOnSuccessInc) then
  107.           fOnSuccessInc(self);
  108.        result := FliValue;
  109.      end { End If }
  110.   else
  111.     begin
  112.       if (FbExceptOnMaxValExceed) then
  113.          raise EMaxExceedError.Create('AccInc result exceeds MaxValue');
  114.       result := 0
  115.     end; { End Else }
  116. end; { End Method. }
  117.  
  118.  
  119. {----------------------------------------------------------}
  120. { Public Method: function TAccumulator.AccDec: LongInt;    }
  121. {----------------------------------------------------------}
  122. { Purpose: Decrements the accumulators current value.      }
  123. {----------------------------------------------------------}
  124. { Returns: Result of computation or 0 (if                  }
  125. {          ExceptOnMaxValExceed is set to False and result }
  126. {          exceeds MaxValue). If ExceptOnMaxValExceed      }
  127. {          is set to true and the result exceeds MaxValue, }
  128. {          an exception called EMaxExceedError will occur. }
  129. {----------------------------------------------------------}
  130. function  TAccumulator.AccDec: LongInt;
  131. begin
  132.   if Assigned(fOnDec) then
  133.      fOnDec(self);
  134.  
  135.   if ( FliValue - 1 <= MaxValue ) or (MaxValue = 0) then
  136.      begin
  137.        Dec(FliValue);
  138.        if Assigned(fOnSuccessDec) then
  139.           fOnSuccessDec(self);
  140.        result := FliValue;
  141.      end { End If }
  142.   else
  143.     begin
  144.       if (FbExceptOnMaxValExceed) then
  145.          raise EMaxExceedError.Create('AccDec result exceeds MaxValue');
  146.       result := 0
  147.     end; { End Else }
  148. end; { End Method. }
  149.  
  150.  
  151. {----------------------------------------------------------}
  152. { Public Method: Add(liInValue: LongInt): LongInt;         }
  153. {----------------------------------------------------------}
  154. { Purpose: Adds the value passed in Param1 to Accumulator  }
  155. {----------------------------------------------------------}
  156. { Returns: Result of computation or 0 (if                  }
  157. {          ExceptOnMaxValExceed is set to False and result }
  158. {          exceeds MaxValue). If ExceptOnMaxValExceed      }
  159. {          is set to true and the result exceeds MaxValue, }
  160. {          an exception called EMaxExceedError will occur. }
  161. {----------------------------------------------------------}
  162. function  TAccumulator.Add(liInValue: LongInt): LongInt;
  163. begin
  164.   if Assigned(fOnAdd) then
  165.      fOnAdd(self);
  166.  
  167.   if ( (FliValue + liInValue) <= MaxValue )  or (MaxValue = 0) then
  168.      begin
  169.        FliValue := ( FliValue + liInValue );
  170.        if Assigned(fOnSuccessAdd) then
  171.           fOnSuccessAdd(self);
  172.        result := FliValue;
  173.      end { End If }
  174.   else
  175.     begin
  176.       if (FbExceptOnMaxValExceed) then
  177.          raise EMaxExceedError.Create('Add result exceeds MaxValue');
  178.       result := 0
  179.     end; { End Else }
  180. end; { End Method. }
  181.  
  182. {----------------------------------------------------------}
  183. { Public Method: function TAccumulator.Subtract(           }
  184. {                            liInValue: LongInt): LongInt; }
  185. {----------------------------------------------------------}
  186. { Purpose: Sets the Accumulator to the result of its       }
  187. {          (current value - Param1).                       }
  188. {----------------------------------------------------------}
  189. { Returns: Result of computation or 0 (if                  }
  190. {          ExceptOnMaxValExceed is set to False and result }
  191. {          exceeds MaxValue). If ExceptOnMaxValExceed      }
  192. {          is set to true and the result exceeds MaxValue, }
  193. {          an exception called EMaxExceedError will occur. }
  194. {----------------------------------------------------------}
  195. function  TAccumulator.Subtract(liInValue: LongInt): LongInt;
  196. begin
  197.   if Assigned(fOnSubtract) then
  198.      fOnSubtract(self);
  199.  
  200.   if ( (FliValue - liInValue) <= MaxValue ) or (MaxValue = 0) then
  201.      begin
  202.        FliValue := ( FliValue - liInValue );
  203.        if Assigned(fOnSuccessSubtract) then
  204.           fOnSuccessSubtract(self);
  205.        result := FliValue;
  206.      end { End If }
  207.   else
  208.     begin
  209.       if (FbExceptOnMaxValExceed) then
  210.          raise EMaxExceedError.Create('Subtract result exceeds MaxValue');
  211.       result := 0
  212.     end; { End Else }
  213. end; { End Method. }
  214.  
  215. {----------------------------------------------------------}
  216. { Public Method: function TAccumulator.Multiply(           }
  217. {                            liInValue: LongInt): LongInt; }
  218. {----------------------------------------------------------}
  219. { Purpose: Sets the Accumulator to the result of its       }
  220. {          current value * Param1.                         }
  221. {----------------------------------------------------------}
  222. { Returns: Result of computation or 0 (if                  }
  223. {          ExceptOnMaxValExceed is set to False and result }
  224. {          exceeds MaxValue). If ExceptOnMaxValExceed      }
  225. {          is set to true and the result exceeds MaxValue, }
  226. {          an exception called EMaxExceedError will occur. }
  227. {----------------------------------------------------------}
  228. function  TAccumulator.Multiply(liInValue: LongInt): LongInt;
  229. begin
  230.   if Assigned(fOnMultiply) then
  231.      fOnMultiply(self);
  232.  
  233.   if ( (FliValue * liInValue) <= MaxValue ) or (MaxValue = 0) then
  234.      begin
  235.        FliValue := ( FliValue * liInValue );
  236.        if Assigned(fOnSuccessMultiply) then
  237.           fOnSuccessMultiply(self);
  238.        result := FliValue;
  239.      end { End If }
  240.   else
  241.     begin
  242.       if (FbExceptOnMaxValExceed) then
  243.          raise EMaxExceedError.Create('Multiply result exceeds MaxValue');
  244.       result := 0
  245.     end; { End Else }
  246. end; { End Method. }
  247.  
  248. {----------------------------------------------------------}
  249. { Public Method: function TAccumulator.Divide(             }
  250. {                          liInValue: LongInt ): LongInt;  }
  251. {----------------------------------------------------------}
  252. { Purpose: Sets the Accumulator to the result of its       }
  253. {          current value DIV Param1.                       }
  254. {----------------------------------------------------------}
  255. { Returns: Result of computation or 0 (if                  }
  256. {          ExceptOnMaxValExceed is set to False and result }
  257. {          exceeds MaxValue). If ExceptOnMaxValExceed      }
  258. {          is set to true and the result exceeds MaxValue, }
  259. {          an exception called EMaxExceedError will occur. }
  260. {----------------------------------------------------------}
  261. function  TAccumulator.Divide(liInValue: LongInt): LongInt;
  262. begin
  263.   if Assigned(fOnDivide) then
  264.      fOnDivide(self);
  265.  
  266.   if ( (FliValue div liInValue) <= MaxValue ) or (MaxValue = 0) then
  267.      begin
  268.        FliValue := ( FliValue div liInValue );
  269.        if Assigned(fOnSuccessDivide) then
  270.           fOnSuccessDivide(self);
  271.        result := FliValue;
  272.      end { End If }
  273.   else
  274.     begin
  275.       if (FbExceptOnMaxValExceed) then
  276.          raise EMaxExceedError.Create('Divide result exceeds MaxValue');
  277.       result := 0
  278.     end; { End Else }
  279. end; { End Method. }
  280.  
  281. {----------------------------------------------------------}
  282. { Public Method: function GetCurrentValue: LongInt;        }
  283. {----------------------------------------------------------}
  284. { Purpose: To retrieve the accumulators current value.     }
  285. {----------------------------------------------------------}
  286. { Returns: The Accumulators current value. If              }
  287. {          ExceptOnMaxValExceed is set to true and the     }
  288. {          Accumulators current value exceeds MaxValue, an }
  289. {          exception called EMaxExceedError will occur.    }
  290. {----------------------------------------------------------}
  291. function  TAccumulator.GetCurrentValue: LongInt;
  292. begin
  293.   if ( FliValue <= MaxValue ) or (MaxValue = 0) then
  294.        result := FliValue
  295.   else
  296.     begin
  297.       if (FbExceptOnMaxValExceed) then
  298.          raise EMaxExceedError.Create('Current value exceeds MaxValue');
  299.       result := FliValue;
  300.     end; { End Else }
  301. end; { End Method. }
  302.  
  303. {----------------------------------------------------------}
  304. { Public Method: procedure TAccumulator.Reset;             }
  305. {----------------------------------------------------------}
  306. { Purpose: Resets Accumulator to value of StartValue       }
  307. {----------------------------------------------------------}
  308. { Returns: Nothing. This is a procedure.                   }
  309. {----------------------------------------------------------}
  310. procedure TAccumulator.Reset;
  311. begin
  312.   FliValue := StartValue;
  313. end; { End Method. }
  314.  
  315. {----------------------------------------------------------}
  316. { Protected Method: procedure SetFliStartValue(            }
  317. {                                     liInValue:LongInt ); }
  318. {----------------------------------------------------------}
  319. { Purpose: Sets Accumulator to value of StartValue when    }
  320. {          StartValue property is assigned.                }
  321. {----------------------------------------------------------}
  322. { Returns: Nothing. This is a procedure.                   }
  323. {----------------------------------------------------------}
  324. procedure TAccumulator.SetFliStartValue(liInValue:LongInt);
  325. begin
  326.   if ( liInValue < MaxValue ) or (MaxValue = 0) then
  327.      begin
  328.        FliStartValue := liInValue;
  329.        FliValue      := liInValue;
  330.      end
  331.   else
  332.     ShowMessage('Start Value must be a smaller value then MaxValue');
  333. end; { End Method. }
  334. {----------------------------------------------------------}
  335. procedure TAccumulator.SetFliMaxValue(liInValue:LongInt);
  336. begin
  337.   if ( liInValue > StartValue ) or (liInValue = 0) then
  338.      FliMaxValue := liInValue
  339.   else
  340.     ShowMessage('Start Value must be a smaller value then MaxValue');
  341. end;
  342. end. { End Unit }
  343.